home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1992 June: ROMin Holiday / ADC Developer CD (1992-06) (''ROMin Holiday'')_iso / Developer Connection - 06-1992.iso / Developer Essentials / DTS Sample Code / System 7.0 Samples / CShell⁄THINK C / Menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-20  |  8.4 KB  |  345 lines  |  [TEXT/MPS ]
  1. /*
  2. ** Apple Macintosh Developer Technical Support
  3. **
  4. ** Program:     CShell
  5. ** File:        menu.c
  6. ** Written by:  Eric Soldan
  7. **
  8. ** Copyright © 1990-1991 Apple Computer, Inc.
  9. ** All rights reserved.
  10. */
  11.  
  12.  
  13.  
  14. /*****************************************************************************/
  15.  
  16.  
  17.  
  18. #include "CShell.h"                /* Get the CShell includes/typedefs, etc.    */
  19. #include "CShellCommon.h"        /* Get the stuff in common with rez.        */
  20. #include "CShell.protos"        /* Get the prototypes for CShell.            */
  21.  
  22. #ifndef __DESK__
  23. #include <Desk.h>
  24. #endif
  25.  
  26. #ifndef __ERRORS__
  27. #include <Errors.h>
  28. #endif
  29.  
  30. #ifndef __MEMORY__
  31. #include <Memory.h>
  32. #endif
  33.  
  34. #ifndef __MENUS__
  35. #include <Menus.h>
  36. #endif
  37.  
  38. #ifndef __TEXTEDITCONTROL__
  39. #include "TextEditControl.h"
  40. #endif
  41.  
  42. #ifndef __TOOLUTILS__
  43. #include <ToolUtils.h>
  44. #endif
  45.  
  46. #ifndef __UTILITIES__
  47. #include "Utilities.h"
  48. #endif
  49.  
  50.  
  51.  
  52. /*****************************************************************************/
  53.  
  54.  
  55.  
  56. extern Boolean    gQuitApplication;
  57. extern Boolean    gHasAppleEvents;
  58. extern Boolean    gHasPPCToolbox;
  59. extern Boolean    gSendToSelf;
  60. extern short    gReplyMode;
  61.  
  62.  
  63.  
  64. /*****************************************************************************/
  65. /*****************************************************************************/
  66.  
  67.  
  68.  
  69. /* Enable and disable menus based on the current state.  The user can only
  70. ** select enabled menu items.  We set up all the menu items before calling
  71. ** MenuSelect or MenuKey, since these are the only times that a menu item can
  72. ** be selected.  Note that MenuSelect is also the only time the user will see
  73. ** menu items.  This approach to deciding what enable/ disable state a menu
  74. ** item has the advantage of concentrating all the decision-making in one
  75. ** routine, as opposed to being spread throughout the application.  Other
  76. ** application designs may take a different approach that is just as valid.
  77. */
  78.  
  79. #pragma segment Menu
  80. void    AdjustMenus(void)
  81. {
  82.     WindowPtr        window;
  83.     MenuHandle        menu;
  84.     short            numWindows;
  85.     Boolean            maxWindows, menuEnabled, redrawMenuBar;
  86.     FileRecHndl        frHndl;
  87.     static Boolean    editMenuEnabled = true;
  88.     static Boolean    communicateMenuEnabled = true;
  89.  
  90.     redrawMenuBar = false;
  91.     window = FrontWindow();
  92.     menu = GetMHandle(mFile);
  93.  
  94.     EnableItem(menu, iNew);                /* Set these for the no-windows state. */
  95.     EnableItem(menu, iOpen);
  96.     if (MaxBlock() < 0x10000L) {
  97.         if (CompactMem(0x10000L) < 0x10000L) {
  98.             DisableItem(menu, iNew);    /* Running low on RAM. */
  99.             DisableItem(menu, iOpen);
  100.         }
  101.     }
  102.  
  103.     DisableItem(menu, iClose);
  104.     DisableItem(menu, iSave);
  105.     DisableItem(menu, iSaveAs);
  106.     DisableItem(menu, iDuplicate);
  107.     DisableItem(menu, iPageSetup);
  108.     DisableItem(menu, iPrint);
  109.         /* Quit is always hilited. */
  110.  
  111.  
  112.  
  113.     if (IsDAWindow(window)) {
  114.         DisableItem(menu, iNew);    /* DAs don't get to do a new. */
  115.         DisableItem(menu, iOpen);    /* DAs don't get to do an open. */
  116.         EnableItem(menu, iClose);    /* Let DAs do a close from the menu. */
  117.     }
  118.  
  119.     if (IsAppWindow(window)) {
  120.         numWindows = GetWindowCount(false, false);
  121.         maxWindows = (numWindows < kMaxNumWindows);
  122.         EnableOrDisableItem(menu, iNew, maxWindows);
  123.         EnableOrDisableItem(menu, iOpen, maxWindows);
  124.             /* Allow a new and open only if max number of files not reached. */
  125.  
  126.         EnableItem(menu, iClose);
  127.         EnableOrDisableItem(menu, iSave, AppWindowDirty(window));
  128.         EnableItem(menu, iSaveAs);
  129.         EnableItem(menu, iDuplicate);
  130.  
  131.         EnableItem(menu, iPageSetup);
  132.         EnableItem(menu, iPrint);
  133.     }
  134.  
  135.  
  136.  
  137.     menu = GetMHandle(mEdit);
  138.     if (IsDAWindow(window)) {        /* A desk accessory may need edit menu. */
  139.         menuEnabled = true;
  140.         EnableItem(menu, iUndo);
  141.         EnableItem(menu, iCut);
  142.         EnableItem(menu, iCopy);
  143.         EnableItem(menu, iPaste);
  144.         EnableItem(menu, iClear);
  145.     } else {
  146.         CTEEditMenu(&menuEnabled, mEdit, iUndo, iCut);
  147.     }
  148.     if (editMenuEnabled != menuEnabled) {
  149.         redrawMenuBar = true;
  150.         if (editMenuEnabled = menuEnabled)
  151.              EnableItem(menu, 0);
  152.         else DisableItem(menu, 0);
  153.     }
  154.  
  155.  
  156.     menu = GetMHandle(mCommunicate);        /* Start by disabling everything. */
  157.     menuEnabled = false;
  158.     CheckItem(menu, iConnectToUser, false);
  159.     DisableItem(menu, iConnectToUser);
  160.     DisableItem(menu, iSendToUser);
  161.  
  162.     if (IsAppWindow(window)) {
  163.  
  164.         frHndl = (FileRecHndl)GetWRefCon(window);
  165.  
  166.         if (!(*frHndl)->fileState.readOnly) {
  167.  
  168.             if (gHasAppleEvents) {
  169.                 EnableItem(menu, iConnectToUser);
  170.                 menuEnabled = true;
  171.                 if ((*frHndl)->doc.connected) EnableItem(menu, iSendToUser);
  172.                 CheckItem(menu, iConnectToUser, (*frHndl)->doc.connected);
  173.             }
  174.         }
  175.     }
  176.     if (communicateMenuEnabled != menuEnabled) {
  177.         redrawMenuBar = true;
  178.         if (communicateMenuEnabled = menuEnabled)
  179.              EnableItem(menu, 0);
  180.         else DisableItem(menu, 0);
  181.     }
  182.  
  183.     if (redrawMenuBar) DrawMenuBar();
  184. }
  185.  
  186.  
  187.  
  188. /*****************************************************************************/
  189.  
  190.  
  191.  
  192. /* This function either enables or disables a menu item. */
  193.  
  194. #pragma segment Menu
  195. void    EnableOrDisableItem(MenuHandle menu, short item, Boolean enable)
  196. {
  197.     if (enable) EnableItem(menu, item);
  198.     else        DisableItem(menu, item);
  199. }
  200.  
  201.  
  202.  
  203. /*****************************************************************************/
  204.  
  205.  
  206.  
  207. /* This is called when an item is chosen from the menu bar (after calling
  208. ** MenuSelect or MenuKey).  It performs the right operation for each command.
  209. ** It is good to have both the result of MenuSelect and MenuKey go to one
  210. ** routine like this to keep everything organized.
  211. */
  212.  
  213. #pragma segment Menu
  214. void    DoMenuCommand(long menuResult)
  215. {
  216.     short        menuID;            /* The resource ID of the selected menu. */
  217.     short        menuItem;        /* The item number of the selected menu. */
  218.     Str255        daName;
  219.     short        daRefNum;
  220.     FileRecHndl    frHndl, newFrHndl;
  221.     OSErr        err;
  222.     WindowPtr    window;
  223.  
  224.     if (window = FrontWindow())
  225.         frHndl = (FileRecHndl)GetWRefCon(window);
  226.             /* frHndl is valid only if it is one of our windows. */
  227.  
  228.     menuID = HiWord(menuResult);    /* Use macros for efficiency to get */
  229.     menuItem = LoWord(menuResult);    /* menu item number and menu number. */
  230.  
  231.     switch (menuID) {
  232.  
  233.         case mApple:
  234.             switch (menuItem) {
  235.                 case iAbout:    /* Bring up alert for About. */
  236.                     Alert(rAboutAlert, nil);
  237.                     break;
  238.                 default:        /* All non-About items in this menu are DAs. */
  239.                     GetItem(GetMHandle(mApple), menuItem, daName);
  240.                     daRefNum = OpenDeskAcc(daName);
  241.                     break;
  242.             }
  243.             break;
  244.  
  245.         case mFile:
  246.             switch (menuItem) {
  247.                 case iNew:
  248.                     err = AppNewDocument(&frHndl);
  249.                     if (!err) {
  250.                         if (err = AppNewWindow(frHndl, nil))
  251.                             AppDisposeDocument(frHndl);
  252.                     }
  253.                     if (err) Alert(rErrorAlert, nil);
  254.                     break;
  255.                 case iOpen:
  256.                     err = AppOpenDocument(&frHndl, nil, fsRdWrPerm);
  257.                     if (!err) {
  258.                         if (err = AppNewWindow(frHndl, nil))
  259.                             AppDisposeDocument(frHndl);
  260.                     }
  261.                     if ((err) && (err != userCanceledErr))
  262.                         Alert(rErrorAlert, nil);
  263.                     break;
  264.                 case iClose:
  265.                     DisposeOneWindow(window, iClose);
  266.                     break;
  267.                 case iSave:
  268.                     err = AppSaveDocument(frHndl, window, iSave);
  269.                     if ((err) && (err != userCanceledErr))
  270.                         Alert(rErrorAlert, nil);
  271.                     break;
  272.                 case iSaveAs:
  273.                     err = AppSaveDocument(frHndl, window, iSaveAs);
  274.                     if ((err) && (err != userCanceledErr))
  275.                         Alert(rErrorAlert, nil);
  276.                     break;
  277.                 case iDuplicate:
  278.                     err = AppDuplicateDocument(frHndl, &newFrHndl);
  279.                     if (!err) {
  280.                         if (err = AppNewWindow(newFrHndl, nil))
  281.                             AppDisposeDocument(newFrHndl);
  282.                     }
  283.                     if (err) Alert(rErrorAlert, nil);
  284.                     break;
  285.                 case iPageSetup:
  286.                     DoSetCursor(&QD(arrow));
  287.                     PresentStyleDialog(frHndl);
  288.                     break;
  289.                 case iPrint:
  290.                     DoSetCursor(&QD(arrow));
  291.                     err = noErr;
  292.                     if (!(*frHndl)->doc.printRecValid)
  293.                         err = PresentStyleDialog(frHndl);
  294.                     if (!err) {
  295.                         err = AppPrintDocument(frHndl, true, true);
  296.                         AppPrintDocument(nil, false, false);
  297.                     }
  298.                     if ((err) && (err != userCanceledErr)) Alert(rErrorAlert, nil);
  299.                     break;
  300.                 case iQuit:
  301.                     gQuitApplication = DisposeAllWindows();
  302.                     break;
  303.             }
  304.             break;
  305.  
  306.         case mEdit:            /* Call SystemEdit for DA editing & MultiFinder. */
  307.             if (IsAppWindow(window)) {
  308.                 switch (menuItem) {
  309.                     case iUndo:
  310.                         CTEUndo();
  311.                         break;
  312.                     case iCut:
  313.                     case iCopy:
  314.                     case iPaste:
  315.                     case iClear:
  316.                         CTEClipboard(menuItem - iCut + 2);
  317.                         break;
  318.                 }
  319.                 if (menuItem != iCopy) (*frHndl)->fileState.docDirty = true;
  320.             }
  321.             else SystemEdit(menuItem - 1);
  322.             break;
  323.  
  324.         case mCommunicate:
  325.             switch (menuItem) {
  326.                 case iConnectToUser:
  327.                     DoSetCursor(&QD(arrow));
  328.                     if ((*frHndl)->doc.connected) SendMessage(frHndl, kDisconnectMssg);
  329.                     else                          SendConnect(frHndl);
  330.                     break;
  331.                 case iSendToUser:
  332.                     SendMessage(frHndl, kTextMssg);
  333.                     break;
  334.  
  335.             }
  336.             break;
  337.  
  338.     }
  339.  
  340.     HiliteMenu(0);        /* Unhighlight what MenuSelect (or MenuKey) hilited. */
  341. }
  342.  
  343.  
  344.  
  345.